Method: static {...}

1: /**
2: * Copyright (C) 2022 Czech Technical University in Prague
3: *
4: * This program is free software: you can redistribute it and/or modify it under
5: * the terms of the GNU General Public License as published by the Free Software
6: * Foundation, either version 3 of the License, or (at your option) any
7: * later version.
8: *
9: * This program is distributed in the hope that it will be useful, but WITHOUT
10: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11: * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12: * details. You should have received a copy of the GNU General Public License
13: * along with this program. If not, see <http://www.gnu.org/licenses/>.
14: */
15: package cz.cvut.kbss.ontodriver.owlapi;
16:
17: import cz.cvut.kbss.ontodriver.descriptor.*;
18: import cz.cvut.kbss.ontodriver.model.Axiom;
19: import cz.cvut.kbss.ontodriver.owlapi.connector.Connector;
20: import cz.cvut.kbss.ontodriver.owlapi.connector.OntologySnapshot;
21: import cz.cvut.kbss.ontodriver.owlapi.exception.OwlapiDriverException;
22: import cz.cvut.kbss.ontodriver.owlapi.list.ListHandler;
23: import cz.cvut.kbss.ontodriver.owlapi.query.OwlapiPreparedStatement;
24: import cz.cvut.kbss.ontodriver.owlapi.query.OwlapiStatement;
25: import cz.cvut.kbss.ontodriver.owlapi.query.StatementExecutorFactory;
26: import cz.cvut.kbss.ontodriver.owlapi.util.IdentifierGenerator;
27: import org.semanticweb.owlapi.model.OWLAxiom;
28: import org.semanticweb.owlapi.model.OWLDataFactory;
29: import org.semanticweb.owlapi.model.OWLOntology;
30: import org.semanticweb.owlapi.model.OWLOntologyChange;
31: import org.semanticweb.owlapi.reasoner.OWLReasoner;
32:
33: import java.net.URI;
34: import java.util.*;
35:
36: /**
37: * Adapter between OntoDriver API and OWLAPI.
38: */
39: public class OwlapiAdapter {
40:
41: private final Connector connector;
42: private OntologySnapshot ontologySnapshot;
43:
44: private StatementExecutorFactory statementExecutorFactory;
45:
46: private TransactionState transactionState = TransactionState.INITIAL;
47: private List<OWLOntologyChange> pendingChanges = new ArrayList<>();
48:
49: private enum TransactionState {
50: INITIAL, RUNNING
51: }
52:
53: public OwlapiAdapter(Connector connector) {
54: this.connector = connector;
55: }
56:
57: private void startTransactionIfNotActive() {
58: if (transactionState == TransactionState.INITIAL) {
59: this.ontologySnapshot = connector.getOntologySnapshot();
60: this.transactionState = TransactionState.RUNNING;
61: this.statementExecutorFactory = new StatementExecutorFactory(ontologySnapshot, connector);
62: }
63: }
64:
65: void commit() {
66: if (transactionState != TransactionState.RUNNING) {
67: return;
68: }
69: if (!pendingChanges.isEmpty()) {
70: connector.applyChanges(pendingChanges);
71: this.pendingChanges = new ArrayList<>();
72: }
73: transactionCleanup();
74: }
75:
76: private void transactionCleanup() {
77: connector.closeSnapshot(ontologySnapshot);
78: this.ontologySnapshot = null;
79: this.transactionState = TransactionState.INITIAL;
80: }
81:
82: void rollback() {
83: if (transactionState != TransactionState.RUNNING) {
84: return;
85: }
86: if (!pendingChanges.isEmpty()) {
87: pendingChanges = new ArrayList<>();
88: }
89: transactionCleanup();
90: }
91:
92: boolean isConsistent(URI context) {
93: startTransactionIfNotActive();
94:
95: return reasoner().isConsistent();
96: }
97:
98: private OWLReasoner reasoner() {
99: return ontologySnapshot.getReasoner();
100: }
101:
102: private OWLOntology ontology() {
103: return ontologySnapshot.getOntology();
104: }
105:
106: private OWLDataFactory dataFactory() {
107: return ontologySnapshot.getDataFactory();
108: }
109:
110: List<URI> getContexts() {
111: startTransactionIfNotActive();
112: return Collections.singletonList(connector.getOntologyUri());
113: }
114:
115: boolean containsAxiom(Axiom<?> axiom, Set<URI> contexts) {
116: startTransactionIfNotActive();
117: final Collection<OWLAxiom> owlAxiom = asOwlAxioms(axiom);
118: boolean contains;
119: for (OWLAxiom ax : owlAxiom) {
120: if (axiom.getAssertion().isInferred()) {
121: contains = reasoner().isEntailed(ax);
122: } else {
123: contains = ontology().containsAxiom(ax);
124: }
125: if (contains) {
126: return true;
127: }
128: }
129: return false;
130: }
131:
132: boolean isInferred(Axiom<?> axiom, Set<URI> contexts) {
133: startTransactionIfNotActive();
134: final Collection<OWLAxiom> owlAxiom = asOwlAxioms(axiom);
135: reasoner().flush();
136: return owlAxiom.stream().anyMatch(a -> reasoner().isEntailed(a) && !ontology().containsAxiom(a));
137: }
138:
139: private Collection<OWLAxiom> asOwlAxioms(Axiom<?> axiom) {
140: final Collection<OWLAxiom> owlAxioms = new ArrayList<>(3);
141: final AxiomAdapter axiomAdapter = new AxiomAdapter(dataFactory());
142: switch (axiom.getAssertion().getType()) {
143: case CLASS:
144: owlAxioms.add(axiomAdapter.toOwlClassAssertionAxiom(axiom));
145: break;
146: case OBJECT_PROPERTY:
147: owlAxioms.add(axiomAdapter.toOwlObjectPropertyAssertionAxiom(axiom));
148: break;
149: case DATA_PROPERTY:
150: owlAxioms.add(axiomAdapter.toOwlDataPropertyAssertionAxiom(axiom));
151: break;
152: case ANNOTATION_PROPERTY:
153: owlAxioms.add(axiomAdapter.toOwlAnnotationPropertyAssertionAxiom(axiom));
154: break;
155: default:
156: owlAxioms.add(axiomAdapter.toOwlClassAssertionAxiom(axiom));
157: owlAxioms.add(axiomAdapter.toOwlObjectPropertyAssertionAxiom(axiom));
158: owlAxioms.add(axiomAdapter.toOwlDataPropertyAssertionAxiom(axiom));
159: owlAxioms.add(axiomAdapter.toOwlAnnotationPropertyAssertionAxiom(axiom));
160: break;
161: }
162: return owlAxioms;
163: }
164:
165: Collection<Axiom<?>> find(AxiomDescriptor descriptor) {
166: startTransactionIfNotActive();
167: return new MainAxiomLoader(this, ontologySnapshot).findAxioms(descriptor);
168: }
169:
170: void persist(AxiomValueDescriptor descriptor) {
171: startTransactionIfNotActive();
172: new AxiomSaver(this, ontologySnapshot).persist(descriptor);
173: }
174:
175: URI generateIdentifier(URI classUri) {
176: startTransactionIfNotActive();
177: return new IdentifierGenerator(ontology()).generateIdentifier(classUri);
178: }
179:
180: void update(AxiomValueDescriptor descriptor) {
181: startTransactionIfNotActive();
182: new EpistemicAxiomRemover(this, ontologySnapshot).remove(descriptor);
183: new AxiomSaver(this, ontologySnapshot).persist(descriptor);
184: }
185:
186: void remove(AxiomDescriptor descriptor) {
187: startTransactionIfNotActive();
188: new EpistemicAxiomRemover(this, ontologySnapshot).remove(descriptor);
189: }
190:
191: TypesHandler getTypesHandler() {
192: startTransactionIfNotActive();
193: return new TypesHandler(this, ontologySnapshot);
194: }
195:
196: PropertiesHandler getPropertiesHandler() {
197: startTransactionIfNotActive();
198: return new PropertiesHandler(this, ontologySnapshot);
199: }
200:
201: public void addTransactionalChanges(Collection<OWLOntologyChange> changes) {
202: pendingChanges.addAll(changes);
203: }
204:
205: public ListHandler<SimpleListDescriptor, SimpleListValueDescriptor> getSimpleListHandler() {
206: startTransactionIfNotActive();
207: return ListHandler.getSimpleListHandler(this, ontologySnapshot);
208: }
209:
210: public ListHandler<ReferencedListDescriptor, ReferencedListValueDescriptor> getReferencedListHandler() {
211: startTransactionIfNotActive();
212: return ListHandler.getReferencedListHandler(this, ontologySnapshot);
213: }
214:
215: public OwlapiStatement createStatement(OwlapiConnection connection) {
216: startTransactionIfNotActive();
217: return new OwlapiStatement(statementExecutorFactory, connection);
218: }
219:
220: public OwlapiPreparedStatement prepareStatement(String statement, OwlapiConnection connection) {
221: startTransactionIfNotActive();
222: return new OwlapiPreparedStatement(statementExecutorFactory, connection, statement);
223: }
224:
225: public <T> T unwrap(Class<T> cls) throws OwlapiDriverException {
226: startTransactionIfNotActive();
227: if (cls.isAssignableFrom(this.getClass())) {
228: return cls.cast(this);
229: } else if (cls.isAssignableFrom(OWLOntology.class)) {
230: return cls.cast(ontology());
231: } else if (cls.isAssignableFrom(OWLReasoner.class)) {
232: return cls.cast(reasoner());
233: }
234: throw new OwlapiDriverException("Unsupported type " + cls);
235: }
236: }